import 'dart:io';
import 'dart:convert';
import 'dart:math';
import 'dart:typed_data';
import 'package:flutter/foundation.dart';
import 'package:spreadsheet_decoder/spreadsheet_decoder.dart';

import '../models/question_model.dart';
import 'package:path_provider/path_provider.dart';
import 'package:excel/excel.dart';

class ExcelImportService {
  // 获取考试配置信息
  static Future<Map<String, dynamic>?> getExamConfig() async {
    // 创建默认配置
    return {
      "id": "default_exam_${DateTime.now().millisecondsSinceEpoch}",
      "title": "默认考试",
      "description": "包含多种题型的综合测试",
      "duration": 60,
      "passing_score": 60,
      "total_score": 100,
    };
  }
  
  // 从Excel文件导入试题（支持真实Excel文件）
  // 注意：当加载多个Excel试题时，每个学生只会被分配一套试题
  // 一旦某个学生使用过某套试题，其他学生将不能再使用该试题
  // 试题分配由ExamService.getAvailableExamForStudent和assignExamToStudent方法处理
  static Future<List<Question>> importQuestionsFromExcelFile(File file) async {
    try {
      debugPrint('开始导入Excel文件: ${file.path}');
      
      // 检查文件是否为Excel文件
      final fileName = file.path.toLowerCase();
      if (!fileName.endsWith('.xlsx') && !fileName.endsWith('.xls')) {
        debugPrint('文件不是Excel格式: $fileName');
        return [];
        
      }

      // 优先使用增强的Excel导入服务
      // debugPrint('🚀 使用增强Excel导入服务');
      // final enhancedResult = await _importFromExcelEnhanced(file);

      // if (enhancedResult.isNotEmpty) {
      //   debugPrint('✅ 增强服务导入成功，题目数量: ${enhancedResult.length}');
      //   return enhancedResult;
      // }

      debugPrint('⚠️ 增强服务导入失败，回退到原始方法');

      // 显示支持的格式信息
      final fileExtension = fileName.endsWith('.xlsx') ? 'XLSX' : 'XLS';
      debugPrint('检测到Excel文件格式: $fileExtension');

      // 使用增强的Excel处理逻辑
      // 预检查文件格式（放宽验证，允许更多格式）
      if (!await _validateExcelFile(file, fileExtension)) {
        debugPrint('Excel文件格式验证失败，但将尝试解析');
        // 不直接返回，而是继续尝试解析
      }

      // 读取Excel文件内容
      final bytes = await file.readAsBytes();
      debugPrint('文件大小: ${bytes.length} 字节');

      // 检测文件格式
      final fileFormat = _detectExcelFormat(bytes);
      debugPrint('检测到Excel文件格式: $fileFormat');

      Excel? excel;
      try {
        // 根据文件格式选择不同的解析策略
        excel = await _parseExcelWithFallback(bytes, fileFormat, fileName);
        if (excel != null) {
          debugPrint('Excel文件解析成功');
        }
      } catch (e) {
        debugPrint('Excel文件解析失败: $e');
        debugPrint('文件大小: ${bytes.length} 字节');
        debugPrint('文件头: ${bytes.take(16).map((b) => b.toRadixString(16).padLeft(2, '0')).join(' ')}');

        // 提供更详细的错误信息和解决方案
        _logDetailedErrorInfo(fileName, fileFormat, bytes);
        return [];
      }

      if (excel == null || excel.sheets.isEmpty) {
        debugPrint('Excel文件没有工作表或解析失败');
        return [];
      }
      
      // 获取第一个工作表
      final sheet = excel.sheets.values.first;
      
      if (sheet.maxRows < 2) {
        debugPrint('Excel文件没有足够的行数据');
        return [];
      }
      
      // 解析表头
      final headers = <String, int>{};
      final headerRow = sheet.row(0);

      // 解码表头内容
      for (int i = 0; i < headerRow.length; i++) {
        try {
          final value = _getCellStringValue(headerRow[i]);
          if (value.isNotEmpty) {
            // 尝试进行base64解码
            final decodedValue = utf8.decode(base64.decode(value));
            print('解码后的表头内容: $decodedValue');
            headers[decodedValue] = i;
          }
        } catch (e) {
          // 如果解码失败，使用原始值
          final value = _getCellStringValue(headerRow[i]); 
          if (value.isNotEmpty) {
            headers[value] = i;
          }
        }
      }
      
      for (int i = 0; i < headerRow.length; i++) {
        final value = _getCellStringValue(headerRow[i]);
        print('原始表头内容: $value');
        if (value.isNotEmpty) {
          headers[value] = i;
        }
      }

      // 打印解码后的表头内容
      debugPrint('解码后的表头内容:');
      headers.forEach((key, value) {
        debugPrint('  $key: $value');
      });
      
      debugPrint('Excel表头: $headers');
      
      // 检查必要的列
      if (!headers.containsKey('题目名称') || 
          !headers.containsKey('题目类型') || 
          (!headers.containsKey('题目分数') && !headers.containsKey('题目难度')) ||
          !headers.containsKey('题目答案')) {
        debugPrint('Excel文件缺少必要的列：需要题目名称、题目类型、题目答案，以及题目分值或题目难度中的至少一个');
        return [];
      }
      
      // 读取数据行
      final questions = <Question>[];
      
      for (int i = 1; i <    sheet.maxRows; i++) {
        debugPrint('正在处理第 $i 行数据');
        try {
          final row = sheet.row(i);
          
          // 获取必要的字段
          String idValue = headers.containsKey('题目id') ? 
              _getCellStringValue(row[headers['题目id']!]) : '';
          idValue = utf8.decode(base64.decode(idValue));
          debugPrint('题目id-------: $idValue');
          final id = idValue.isNotEmpty ? 
              idValue : 'q${DateTime.now().millisecondsSinceEpoch}_$i';
          
          String text = _getCellStringValue(row[headers['题目名称']!]);
          text = utf8.decode(base64.decode(text));
          debugPrint('题目名称-------: $text');
          String type = _getCellStringValue(row[headers['题目类型']!]);
          type = utf8.decode(base64.decode(type));
          debugPrint('题目类型: $type');
          
          // 获取知识点
          String knowledgePoint = '';
          if (headers.containsKey('知识点')) {
            knowledgePoint = _getCellStringValue(row[headers['知识点']!]);
            knowledgePoint = utf8.decode(base64.decode(knowledgePoint));
          }
          
          // 获取题目难度
          String difficulty = '';
          if (headers.containsKey('题目难度')) {
            difficulty = _getCellStringValue(row[headers['题目难度']!]);
            difficulty = utf8.decode(base64.decode(difficulty));
          }
          
          // 分值可以直接从Excel中读取或根据难度计算
          int score = 10; // 默认分值
          if (headers.containsKey('题目分数')) {
            String scoreStr = _getCellStringValue(row[headers['题目分数']!]);
            print('题目分数-------: $scoreStr');
            scoreStr = utf8.decode(base64.decode(scoreStr));
            score = int.tryParse(scoreStr) ?? 
                    (difficulty.isNotEmpty ? _getDifficultyScore(difficulty) : 10);
          } else if (difficulty.isNotEmpty) {
            score = _getDifficultyScore(difficulty);
          }
          
          // 获取答案分析
          String analysis = '';
          if (headers.containsKey('答案分析')) {
            analysis = _getCellStringValue(row[headers['答案分析']!]);
            analysis = utf8.decode(base64.decode(analysis));
          }
          
          // 创建不同类型的题目
          Question? question;
          debugPrint('-----------------题目类型: $type');
          
          switch (type) {
            case '1': // 单选题
              // 获取选项和答案
              String optionsStr = headers.containsKey('题目选项') ? 
                  _getCellStringValue(row[headers['题目选项']!]) : '';
              optionsStr = utf8.decode(base64.decode(optionsStr));
              String answer = _getCellStringValue(row[headers['题目答案']!]);
              answer = utf8.decode(base64.decode(answer));
              // 解析选项
              final choices = _parseChoices(optionsStr);
              
              // 寻找正确选项的索引
              int correctOption = 0;
              for (int j = 0; j < choices.length; j++) {
                if (choices[j].id == answer) {
                  correctOption = j;
                  break;
                }
              }
              
              question = SingleChoiceQuestion(
                id: id,
                text: text,
                score: score,
                choices: choices,
                correctOption: correctOption,
                analysis: analysis.isNotEmpty ? analysis : null,
              );
              break;
              
            case '2': // 多选题
              // 获取选项和答案
              String optionsStr = headers.containsKey('题目选项') ? 
                  _getCellStringValue(row[headers['题目选项']!]) : '';
              optionsStr = utf8.decode(base64.decode(optionsStr));
              String answer = _getCellStringValue(row[headers['题目答案']!]);
              answer = utf8.decode(base64.decode(answer));
              // 解析选项
              final choices = _parseChoices(optionsStr);
              
              // 解析多选答案
              List<int> correctOptions = [];
              for (int j = 0; j < answer.length; j++) {
                String option = answer[j];
                for (int k = 0; k < choices.length; k++) {
                  if (choices[k].id == option) {
                    correctOptions.add(k);
                    break;
                  }
                }
              }
              
              question = MultipleChoiceQuestion(
                id: id,
                text: text,
                score: score,
                choices: choices,
                correctOptions: correctOptions,
                analysis: analysis.isNotEmpty ? analysis : null,
              );
              break;
              
            case '4': // 填空题
              final rawAnswer = _getCellStringValue(row[headers['题目答案']!]);

              // 先解码Base64答案
              String decodedAnswer;
              try {
                decodedAnswer = utf8.decode(base64.decode(rawAnswer));
                debugPrint('填空题答案解码:');
                debugPrint('  原始答案(Base64): $rawAnswer');
                debugPrint('  解码后答案: $decodedAnswer');
              } catch (e) {
                debugPrint('填空题答案解码失败: $e，使用原始答案');
                decodedAnswer = rawAnswer;
              }

              // 检查是否为多空填空题（支持中英文逗号）
              final hasEnglishComma = decodedAnswer.contains(',');
              final hasChineseComma = decodedAnswer.contains('，');
              final isMultiBlank = hasEnglishComma || hasChineseComma;

              // 根据逗号类型分割答案
              List<String> answers;
              if (hasEnglishComma) {
                answers = decodedAnswer.split(',').map((e) => e.trim()).toList();
              } else if (hasChineseComma) {
                answers = decodedAnswer.split('，').map((e) => e.trim()).toList();
              } else {
                answers = [decodedAnswer.trim()];
              }

              final blankCount = answers.length;

              debugPrint('填空题处理:');
              debugPrint('  最终答案: $decodedAnswer');
              debugPrint('  包含英文逗号: $hasEnglishComma');
              debugPrint('  包含中文逗号: $hasChineseComma');
              debugPrint('  是否多空: $isMultiBlank');
              debugPrint('  空的数量: $blankCount');
              debugPrint('  分解答案: $answers');

              question = FillBlankQuestion(
                id: id,
                text: text,
                score: score,
                correctAnswer: decodedAnswer,
                analysis: analysis.isNotEmpty ? analysis : null,
              );
              break;
              
            case '3': // 判断题
              // final answer = _getCellStringValue(row[headers['题目答案']!]);

              String answer = _getCellStringValue(row[headers['题目答案']!]);
              answer = utf8.decode(base64.decode(answer));


              bool isTrue = answer == '对' ;
              
              question = TrueOrFalseQuestion(
                id: id,
                text: text,
                score: score,
                correctAnswer: isTrue,
                analysis: analysis.isNotEmpty ? analysis : null,
              );
              break;
              
            case '5': // 简答题
              final answer = _getCellStringValue(row[headers['题目答案']!]);
              
              question = ShortAnswerQuestion(
                id: id,
                text: text,
                score: score,
                referencedAnswer: answer,
                analysis: analysis.isNotEmpty ? analysis : null,
              );
              break;
          }
          
          if (question != null) {
            questions.add(question);
            debugPrint('成功导入题目: ID=$id, 类型=$type, 分值=$score,');
          }
        } catch (e) {
          debugPrint('解析第 ${i+1} 行数据错误: $e');
        }
      }
      
      debugPrint('成功导入 ${questions.length} 道题目');
      return questions;
    } catch (e) {
      debugPrint('导入Excel文件错误: $e');
      return [];
    }
  }
  
  // 从Excel单元格获取字符串值
  static String _getCellStringValue(dynamic cell) {
    if (cell == null) return '';
    
    if (cell is Data) {
      return cell.value?.toString() ?? '';
    }
    
    return cell.toString().trim();
  }
  
  // 创建模板Excel文件并保存到公共下载目录
  static Future<String?> createAndSaveExcelTemplate() async {
    try {
      // 获取公共目录路径
      String? dirPath;
      if (Platform.isAndroid) {
        dirPath = '/storage/emulated/0/Download/ExamApp';
      } else {
        final directory = await getApplicationDocumentsDirectory();
        dirPath = '${directory.path}/ExamApp';
      }
      
      // 创建目录
      final dir = Directory(dirPath);
      if (!await dir.exists()) {
        await dir.create(recursive: true);
      }
      
      // 创建Excel对象
      final excel = Excel.createExcel();
      final sheetName = excel.getDefaultSheet() ?? 'Sheet1';
      final sheet = excel.sheets[sheetName]!;
      
      // 添加表头 - 按照用户需求添加所有字段
      final headers = [
        '题目id', '题目名称', '题目类型', '知识点', '题目难度', '题目选项', '题目答案', '答案分析'
      ];
      
      for (int i = 0; i < headers.length; i++) {
        sheet.cell(CellIndex.indexByColumnRow(columnIndex: i, rowIndex: 0))
          .value = headers[i];
      }
      
      // 添加样例数据 - 单选题
      int row = 1;
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 0, rowIndex: row))
        .value = 'q1';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 1, rowIndex: row))
        .value = '单选题示例: 1+1=?';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 2, rowIndex: row))
        .value = '单选';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 3, rowIndex: row))
        .value = '基础数学';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 4, rowIndex: row))
        .value = '基础';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 5, rowIndex: row))
        .value = '[{"name":"A","desc":"1"},{"name":"B","desc":"2"},{"name":"C","desc":"3"},{"name":"D","desc":"4"}]';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 6, rowIndex: row))
        .value = 'B';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 7, rowIndex: row))
        .value = '答案是2，这是最基础的加法运算';
      
      // 多选题
      row++;
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 0, rowIndex: row))
        .value = 'q2';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 1, rowIndex: row))
        .value = '多选题示例: 下列哪些是编程语言?';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 2, rowIndex: row))
        .value = '多选';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 3, rowIndex: row))
        .value = '计算机基础';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 4, rowIndex: row))
        .value = '中等';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 5, rowIndex: row))
        .value = '[{"name":"A","desc":"Java"},{"name":"B","desc":"Python"},{"name":"C","desc":"HTML"},{"name":"D","desc":"SQL"}]';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 6, rowIndex: row))
        .value = 'AB';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 7, rowIndex: row))
        .value = 'Java和Python是编程语言，HTML是标记语言，SQL是查询语言';
      
      // 填空题
      row++;
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 0, rowIndex: row))
        .value = 'q3';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 1, rowIndex: row))
        .value = '填空题示例: 中国的首都是____';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 2, rowIndex: row))
        .value = '填空';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 3, rowIndex: row))
        .value = '地理常识';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 4, rowIndex: row))
        .value = '基础';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 5, rowIndex: row))
        .value = '';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 6, rowIndex: row))
        .value = '北京';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 7, rowIndex: row))
        .value = '中国的首都是北京，这是基本的地理常识';
      
      // 判断题
      row++;
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 0, rowIndex: row))
        .value = 'q4';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 1, rowIndex: row))
        .value = '判断题示例: 地球是太阳系中最大的行星';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 2, rowIndex: row))
        .value = '判断';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 3, rowIndex: row))
        .value = '天文知识';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 4, rowIndex: row))
        .value = '基础';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 5, rowIndex: row))
        .value = '';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 6, rowIndex: row))
        .value = 'false';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 7, rowIndex: row))
        .value = '错误。太阳系中最大的行星是木星，地球是太阳系中的第三大行星';
      
      // 简答题
      row++;
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 0, rowIndex: row))
        .value = 'q5';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 1, rowIndex: row))
        .value = '简答题示例: 简述植物的光合作用过程';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 2, rowIndex: row))
        .value = '简答';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 3, rowIndex: row))
        .value = '生物学';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 4, rowIndex: row))
        .value = '困难';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 5, rowIndex: row))
        .value = '';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 6, rowIndex: row))
        .value = '植物通过叶绿素吸收光能，将二氧化碳和水转化为葡萄糖和氧气。此过程在叶绿体中进行，是植物获取能量的主要方式。';
      sheet.cell(CellIndex.indexByColumnRow(columnIndex: 7, rowIndex: row))
        .value = '光合作用是植物利用光能将无机物转化为有机物的过程。植物通过叶绿体中的叶绿素捕获光能，将水分解出氧气，同时将二氧化碳还原为有机物。光合作用分为光反应和暗反应两个阶段。';
      
      // 保存Excel文件
      final filePath = '$dirPath/考试题目模板.xlsx';
      final file = File(filePath);
      await file.writeAsBytes(excel.encode()!);
      
      debugPrint('模板Excel文件已保存到: $filePath');
      return filePath;
    } catch (e) {
      debugPrint('创建Excel模板文件错误: $e');
      return null;
    }
  }
  
  // 根据难度返回分数
  static int _getDifficultyScore(String? difficulty) {
    switch (difficulty) {
      case '基础':
        return 5;
      case '中等':
        return 10;
      case '困难':
        return 15;
      default:
        return 10; // 默认分值
    }
  }
  
  // 解析选项字符串为Choice对象列表
  static List<Choice> _parseChoices(String? optionsJson) {
    if (optionsJson == null || optionsJson.isEmpty) {
      return [];
    }
    
    try {
      final List<dynamic> options = jsonDecode(optionsJson);
      return options.map((option) {
        return Choice(
          id: option['name'] ?? '',
          text: option['desc'] ?? '',
        );
      }).toList();
    } catch (e) {
      debugPrint('Error parsing choices: $e');
      return [];
    }
  }

  // 验证Excel文件格式
  static Future<bool> _validateExcelFile(File file, String expectedFormat) async {
    try {
      final bytes = await file.readAsBytes();

      if (bytes.isEmpty) {
        debugPrint('文件为空');
        return false;
      }

      if (bytes.length < 100) {
        debugPrint('文件太小，可能不是有效的Excel文件');
        return false;
      }

      // 检查文件头标识
      if (expectedFormat == 'XLSX') {
        // XLSX文件是ZIP格式，应该以PK开头
        if (bytes.length >= 2 && bytes[0] == 0x50 && bytes[1] == 0x4B) {
          debugPrint('XLSX文件格式验证通过（标准ZIP格式）');
          return true;
        }
        // 检查是否是OLE2格式的XLSX文件（某些Excel版本会这样保存）
        else if (bytes.length >= 8 &&
                 bytes[0] == 0xD0 && bytes[1] == 0xCF &&
                 bytes[2] == 0x11 && bytes[3] == 0xE0 &&
                 bytes[4] == 0xA1 && bytes[5] == 0xB1 &&
                 bytes[6] == 0x1A && bytes[7] == 0xE1) {
          debugPrint('XLSX文件格式验证通过（OLE2格式）');
          return true;
        } else {
          debugPrint('XLSX文件格式验证失败：文件头不正确');
          debugPrint('文件头字节: ${bytes.take(8).map((b) => b.toRadixString(16).padLeft(2, '0')).join(' ')}');
          // 对于XLSX文件，即使文件头不匹配，也尝试解析
          debugPrint('将尝试解析该XLSX文件');
          return true;
        }
      } else if (expectedFormat == 'XLS') {
        // XLS文件的魔数检查
        // 老版本Excel文件可能有不同的文件头
        // 常见的XLS文件头: D0CF11E0 (OLE2格式)
        if (bytes.length >= 8) {
          // 检查OLE2文件头
          if (bytes[0] == 0xD0 && bytes[1] == 0xCF &&
              bytes[2] == 0x11 && bytes[3] == 0xE0 &&
              bytes[4] == 0xA1 && bytes[5] == 0xB1 &&
              bytes[6] == 0x1A && bytes[7] == 0xE1) {
            debugPrint('XLS文件格式验证通过（OLE2格式）');
            return true;
          }

          // 检查BIFF格式（较老的Excel格式）
          if (bytes[0] == 0x09 && (bytes[1] == 0x08 || bytes[1] == 0x00)) {
            debugPrint('XLS文件格式验证通过（BIFF格式）');
            return true;
          }

          // 如果文件头不匹配，但文件扩展名是xls，给出警告但允许尝试解析
          debugPrint('XLS文件格式警告：文件头不是标准格式，但将尝试解析');
          debugPrint('文件头字节: ${bytes.take(8).map((b) => b.toRadixString(16).padLeft(2, '0')).join(' ')}');
          return true; // 仍然尝试解析
        }
      }

      debugPrint('文件格式验证失败：无法识别的格式');
      return false;

    } catch (e) {
      debugPrint('文件格式验证异常: $e');
      return false;
    }
  }

  // 检测Excel文件格式
  static String _detectExcelFormat(List<int> bytes) {
    if (bytes.length < 8) return 'UNKNOWN';

    // 检查ZIP格式（标准XLSX）
    if (bytes[0] == 0x50 && bytes[1] == 0x4B && bytes[2] == 0x03 && bytes[3] == 0x04) {
      return 'XLSX';
    }

    // 检查OLE2格式（传统XLS或OLE2格式的XLSX）
    if (bytes[0] == 0xD0 && bytes[1] == 0xCF && bytes[2] == 0x11 && bytes[3] == 0xE0 &&
        bytes[4] == 0xA1 && bytes[5] == 0xB1 && bytes[6] == 0x1A && bytes[7] == 0xE1) {
      return 'OLE2';
    }

    // 检查BIFF格式（老版本XLS）
    if (bytes.length >= 4) {
      final biffSignature = (bytes[2] << 8) | bytes[3];
      if (bytes[0] == 0x09 && bytes[1] == 0x08 && (biffSignature == 0x0005 || biffSignature == 0x0600)) {
        return 'BIFF';
      }
    }

    return 'UNKNOWN';
  }

  // 使用多种策略解析Excel文件
  static Future<Excel?> _parseExcelWithFallback(List<int> bytes, String format, String fileName) async {
    Excel? excel;

    // 策略1: 直接使用Excel.decodeBytes（适用于标准格式）
    try {
      debugPrint('尝试策略1: 直接解析');
      excel = Excel.decodeBytes(bytes);
      if (excel.sheets.isNotEmpty) {
        debugPrint('策略1成功: 直接解析成功');
        return excel;
      }
    } catch (e) {
      debugPrint('策略1失败: $e');
    }

    // 策略2: 如果是OLE2格式，尝试特殊处理
    if (format == 'OLE2') {
      try {
        debugPrint('尝试策略2: OLE2格式特殊处理');
        excel = await _parseOLE2Excel(bytes);
        if (excel != null && excel.sheets.isNotEmpty) {
          debugPrint('策略2成功: OLE2格式解析成功');
          return excel;
        }
      } catch (e) {
        debugPrint('策略2失败: $e');
      }
    }

    // 策略3: 尝试不同的解析参数
    try {
      debugPrint('尝试策略3: 使用不同的解析方式');
      // 尝试创建一个新的Excel对象并解析
      excel = Excel.createExcel();
      excel = Excel.decodeBytes(bytes);
      if (excel.sheets.isNotEmpty) {
        debugPrint('策略3成功: 替代解析方式成功');
        return excel;
      }
    } catch (e) {
      debugPrint('策略3失败: $e');
    }

    debugPrint('所有解析策略都失败了');
    return null;
  }

  // 处理OLE2格式的Excel文件
  static Future<Excel?> _parseOLE2Excel(List<int> bytes) async {
    try {
      // 对于OLE2格式，我们尝试一些特殊的处理方式
      debugPrint('OLE2格式检测到，尝试特殊解析方法');

      // 方法1: 尝试直接解析（某些OLE2格式的XLSX仍然可以被解析）
      try {
        final excel = Excel.decodeBytes(bytes);
        if (excel.sheets.isNotEmpty) {
          debugPrint('OLE2文件直接解析成功');
          return excel;
        }
      } catch (e) {
        debugPrint('OLE2文件直接解析失败: $e');
      }

      // 方法2: 如果直接解析失败，提供用户友好的错误信息
      debugPrint('OLE2格式的Excel文件需要特殊处理');
      debugPrint('建议: 请使用Excel软件打开此文件，然后另存为标准的XLSX格式');

      return null;
    } catch (e) {
      debugPrint('OLE2格式解析异常: $e');
      return null;
    }
  }

  // 记录详细的错误信息
  static void _logDetailedErrorInfo(String fileName, String format, List<int> bytes) {
    debugPrint('=== Excel文件解析失败详细信息 ===');
    debugPrint('文件名: $fileName');
    debugPrint('检测格式: $format');
    debugPrint('文件大小: ${bytes.length} 字节');
    debugPrint('文件头(前16字节): ${bytes.take(16).map((b) => b.toRadixString(16).padLeft(2, '0')).join(' ')}');

    switch (format) {
      case 'OLE2':
        debugPrint('');
        debugPrint('🔍 检测到OLE2格式文件');
        debugPrint('这可能是:');
        debugPrint('  • 传统的XLS文件（Excel 97-2003格式）');
        debugPrint('  • 某些版本Excel保存的XLSX文件（使用了OLE2容器）');
        debugPrint('');
        debugPrint('💡 解决方案:');
        debugPrint('  1. 使用Microsoft Excel打开此文件');
        debugPrint('  2. 选择"文件" → "另存为"');
        debugPrint('  3. 选择"Excel工作簿(*.xlsx)"格式');
        debugPrint('  4. 保存后重新导入');
        debugPrint('');
        debugPrint('  或者:');
        debugPrint('  1. 将文件转换为CSV格式');
        debugPrint('  2. 使用CSV导入功能（如果支持）');
        break;

      case 'BIFF':
        debugPrint('');
        debugPrint('🔍 检测到BIFF格式文件（老版本Excel）');
        debugPrint('💡 解决方案: 请将文件转换为XLSX格式后重新导入');
        break;

      case 'XLSX':
        debugPrint('');
        debugPrint('🔍 检测到标准XLSX格式，但解析失败');
        debugPrint('可能原因:');
        debugPrint('  • 文件损坏或不完整');
        debugPrint('  • 包含不支持的Excel功能');
        debugPrint('  • 文件版本过新或过旧');
        debugPrint('💡 解决方案: 请检查文件完整性，或尝试重新保存');
        break;

      default:
        debugPrint('');
        debugPrint('❌ 无法识别的文件格式');
        debugPrint('💡 请确保文件是有效的Excel文件(.xlsx或.xls)');
    }
    debugPrint('=====================================');
  }

  // 增强的Excel导入方法
  static Future<List<Question>> _importFromExcelEnhanced(File file) async {
    try {
      debugPrint('=== 开始使用增强Excel服务导入文件 ===');
      final fileName = file.path.split('/').last;
      debugPrint('文件名: $fileName');
      debugPrint('文件路径: ${file.path}');

      final bytes = await file.readAsBytes();
      debugPrint('文件大小: ${bytes.length} 字节');

      // 检测文件格式
      final format = _detectExcelFormat(bytes);
      debugPrint('检测到文件格式: $format');

      // 尝试使用spreadsheet_decoder解析
      SpreadsheetDecoder? spreadsheet;

      try {
        if (format == 'XLSX') {
          debugPrint('尝试解析XLSX格式...');
          spreadsheet = SpreadsheetDecoder.decodeBytes(bytes);
          debugPrint('✅ XLSX解析成功');
        } else if (format == 'XLS') {
          debugPrint('尝试解析XLS格式...');
          spreadsheet = SpreadsheetDecoder.decodeBytes(bytes);
          debugPrint('✅ XLS解析成功');
        } else {
          debugPrint('尝试通用解析...');
          spreadsheet = SpreadsheetDecoder.decodeBytes(bytes);
          debugPrint('✅ 通用解析成功');
        }
      } catch (e) {
        debugPrint('❌ $format解析失败: $e');
        return [];
      }

      if (spreadsheet.tables.isEmpty) {
        debugPrint('❌ Excel文件解析失败');
        return [];
      }

      debugPrint('✅ Excel文件解析成功');
      debugPrint('工作表数量: ${spreadsheet.tables.length}');

      // 提取题目
      final questions = await _extractQuestionsFromSpreadsheet(spreadsheet, fileName);

      debugPrint('=== Excel导入完成 ===');
      debugPrint('成功导入题目数量: ${questions.length}');

      return questions;
    } catch (e) {
      debugPrint('❌ 增强Excel导入失败: $e');
      return [];
    }
  }

  // 从电子表格中提取题目
  static Future<List<Question>> _extractQuestionsFromSpreadsheet(
    SpreadsheetDecoder spreadsheet,
    String fileName
  ) async {
    try {
      // 获取第一个工作表
      final tableName = spreadsheet.tables.keys.first;
      final table = spreadsheet.tables[tableName]!;

      debugPrint('工作表名称: $tableName');
      debugPrint('行数: ${table.maxRows}');
      debugPrint('列数: ${table.maxCols}');

      if (table.maxRows < 2) {
        debugPrint('❌ 工作表数据不足');
        return [];
      }

      // 解析表头
      final headers = _parseSpreadsheetHeaders(table);
      if (headers.isEmpty) {
        debugPrint('❌ 无法解析表头');
        return [];
      }

      debugPrint('解析到的表头: $headers');

      // 解析题目数据
      final questions = <Question>[];
      for (int rowIndex = 1; rowIndex < table.maxRows; rowIndex++) {
        try {
          final question = _parseSpreadsheetQuestionRow(table, rowIndex, headers);
          if (question != null) {
            questions.add(question);
            debugPrint('成功解析第$rowIndex行题目:');
            debugPrint('  ID: ${question.id}');
            debugPrint('  标题: ${question.text}');
            debugPrint('  类型: ${question.type}');
            debugPrint('  分数: ${question.score}');
            if (question is SingleChoiceQuestion) {
              debugPrint('  选项数量: ${question.choices.length}');
              debugPrint('  正确答案: ${question.correctOption}');
            } else if (question is MultipleChoiceQuestion) {
              debugPrint('  选项数量: ${question.choices.length}');
              debugPrint('  正确答案: ${question.correctOptions}');
            }
          }
        } catch (e) {
          debugPrint('解析第$rowIndex行时出错: $e');
        }
      }

      return questions;
    } catch (e) {
      debugPrint('提取题目数据时出错: $e');
      return [];
    }
  }

  // 解析电子表格表头
  static Map<String, int> _parseSpreadsheetHeaders(SpreadsheetTable table) {
    final headers = <String, int>{};

    if (table.maxRows == 0) return headers;

    for (int col = 0; col < table.maxCols; col++) {
      final cellValue = table.rows[0][col];
      if (cellValue != null) {
        String headerText = cellValue.toString();

        // 尝试Base64解码
        try {
          if (headerText.isNotEmpty) {
            final decoded = utf8.decode(base64.decode(headerText));
            headerText = decoded;
          }
        } catch (e) {
          // 解码失败，使用原始值
        }

        if (headerText.isNotEmpty) {
          headers[headerText] = col;
        }
      }
    }

    return headers;
  }

  // 解析电子表格题目行
  static Question? _parseSpreadsheetQuestionRow(
    SpreadsheetTable table,
    int rowIndex,
    Map<String, int> headers
  ) {
    try {
      // 获取必需字段
      final idCol = headers['题目id'];
      final titleCol = headers['题目名称'];
      final typeCol = headers['题目类型'];
      final scoreCol = headers['题目分数'];

      if (idCol == null || titleCol == null || typeCol == null) {
        debugPrint('缺少必需的列');
        return null;
      }

      // 读取基本信息
      final rawId = _getSpreadsheetCellValue(table, rowIndex, idCol);
      final rawTitle = _getSpreadsheetCellValue(table, rowIndex, titleCol);
      final typeStr = _getSpreadsheetCellValue(table, rowIndex, typeCol);
      final scoreStr = scoreCol != null ? _getSpreadsheetCellValue(table, rowIndex, scoreCol) : '2';

      debugPrint('原始数据: ID=$rawId, Title=$rawTitle');

      // 解码Base64字段
      final id = _decodeBase64String(rawId);
      final title = _decodeBase64String(rawTitle);

      debugPrint('解码后: ID=$id, Title=$title');

      if (id.isEmpty || title.isEmpty || typeStr.isEmpty) {
        return null;
      }

      // 解析题目类型和分数
      final type = int.tryParse(typeStr) ?? 1;
      final score = _parseSpreadsheetScore(scoreStr);

      // 根据题目类型解析具体内容
      return _createSpreadsheetQuestionByType(table, rowIndex, headers, id, title, type, score);

    } catch (e) {
      debugPrint('解析题目行时出错: $e');
      return null;
    }
  }

  // 获取电子表格单元格值
  static String _getSpreadsheetCellValue(SpreadsheetTable table, int row, int col) {
    try {
      if (row >= table.maxRows || col >= table.maxCols) {
        return '';
      }
      final cell = table.rows[row][col];
      return cell?.toString() ?? '';
    } catch (e) {
      return '';
    }
  }

  // 解码Base64字符串
  static String _decodeBase64String(String input) {
    if (input.isEmpty) return input;

    try {
      return utf8.decode(base64.decode(input));
    } catch (e) {
      return input; // 解码失败，返回原始字符串
    }
  }

  // 解析分数
  static int _parseSpreadsheetScore(String scoreStr) {
    try {
      // 尝试Base64解码
      final decoded = utf8.decode(base64.decode(scoreStr));
      return int.tryParse(decoded) ?? 2;
    } catch (e) {
      return int.tryParse(scoreStr) ?? 2;
    }
  }

  // 根据类型创建题目
  static Question? _createSpreadsheetQuestionByType(
    SpreadsheetTable table,
    int rowIndex,
    Map<String, int> headers,
    String id,
    String title,
    int type,
    int score,
  ) {
    try {
      // 获取选项和答案列
      final optionsCol = headers['题目选项'];
      final answerCol = headers['题目答案'];
      final explanationCol = headers['答案分析'];

      String optionsStr = '';
      String answerStr = '';
      String explanationStr = '';

      if (optionsCol != null) {
        optionsStr = _getSpreadsheetCellValue(table, rowIndex, optionsCol);
        optionsStr = _decodeBase64String(optionsStr);
      }

      if (answerCol != null) {
        answerStr = _getSpreadsheetCellValue(table, rowIndex, answerCol);
        answerStr = _decodeBase64String(answerStr);
      }

      if (explanationCol != null) {
        explanationStr = _getSpreadsheetCellValue(table, rowIndex, explanationCol);
        explanationStr = _decodeBase64String(explanationStr);
      }

      // 根据题目类型处理
      switch (type) {
        case 1: // 单选题
          return _createSpreadsheetSingleChoiceQuestion(id, title, score, optionsStr, answerStr, explanationStr);
        case 2: // 多选题
          return _createSpreadsheetMultipleChoiceQuestion(id, title, score, optionsStr, answerStr, explanationStr);
        case 3: // 判断题
          return _createSpreadsheetTrueFalseQuestion(id, title, score, answerStr, explanationStr);
        case 4: // 填空题
          return _createSpreadsheetFillBlankQuestion(id, title, score, answerStr, explanationStr);
        case 5: // 问答题
          return _createSpreadsheetEssayQuestion(id, title, score, answerStr, explanationStr);
        default:
          debugPrint('未知题目类型: $type');
          return null;
      }
    } catch (e) {
      debugPrint('创建题目时出错: $e');
      return null;
    }
  }

  // 创建单选题
  static Question _createSpreadsheetSingleChoiceQuestion(
    String id, String title, int score, String optionsStr, String answerStr, String explanationStr
  ) {
    debugPrint('🔍 开始解析选项: "$optionsStr"');

    final choiceTexts = _parseSpreadsheetChoices(optionsStr);
    final correctIndex = _findSpreadsheetCorrectChoiceIndex(choiceTexts, answerStr);

    // 创建Choice对象列表
    final choices = choiceTexts.asMap().entries.map((entry) {
      return Choice(
        id: String.fromCharCode(65 + entry.key.toInt()), // A, B, C, D...
        text: entry.value,
      );
    }).toList();

    return SingleChoiceQuestion(
      id: id,
      text: title,
      score: score,
      choices: choices,
      correctOption: correctIndex >= 0 ? correctIndex : 0,
      analysis: explanationStr.isNotEmpty ? explanationStr : null,
    );
  }

  // 其他题型的创建方法（简化版）
  static Question _createSpreadsheetMultipleChoiceQuestion(
    String id, String title, int score, String optionsStr, String answerStr, String explanationStr
  ) {
    final choiceTexts = _parseSpreadsheetChoices(optionsStr);
    final correctAnswers = _parseSpreadsheetMultipleAnswers(answerStr);

    final choices = choiceTexts.asMap().entries.map((entry) {
      return Choice(
        id: String.fromCharCode(65 + entry.key.toInt()),
        text: entry.value,
      );
    }).toList();

    final correctOptions = correctAnswers.map((answer) {
      final index = answer.codeUnitAt(0) - 65;
      return index >= 0 && index < choices.length ? index : 0;
    }).toList();

    return MultipleChoiceQuestion(
      id: id,
      text: title,
      score: score,
      choices: choices,
      correctOptions: correctOptions,
      analysis: explanationStr.isNotEmpty ? explanationStr : null,
    );
  }

  static Question _createSpreadsheetTrueFalseQuestion(
    String id, String title, int score, String answerStr, String explanationStr
  ) {
    final isTrue = answerStr.contains('正确') || answerStr.contains('对') || answerStr.contains('T') || answerStr.contains('true');
    return TrueOrFalseQuestion(
      id: id,
      text: title,
      score: score,
      correctAnswer: isTrue,
      analysis: explanationStr.isNotEmpty ? explanationStr : null,
    );
  }

  static Question _createSpreadsheetFillBlankQuestion(
    String id, String title, int score, String answerStr, String explanationStr
  ) {
    return FillBlankQuestion(
      id: id,
      text: title,
      score: score,
      correctAnswer: answerStr,
      analysis: explanationStr.isNotEmpty ? explanationStr : null,
    );
  }

  static Question _createSpreadsheetEssayQuestion(
    String id, String title, int score, String answerStr, String explanationStr
  ) {
    return ShortAnswerQuestion(
      id: id,
      text: title,
      score: score,
      referencedAnswer: answerStr,
      analysis: explanationStr.isNotEmpty ? explanationStr : null,
    );
  }

  // 解析选项
  static List<String> _parseSpreadsheetChoices(String optionsStr) {
    if (optionsStr.isEmpty) {
      debugPrint('❌ 选项字符串为空');
      return [];
    }

    try {
      // 尝试解析JSON格式
      if (optionsStr.startsWith('[') && optionsStr.endsWith(']')) {
        debugPrint('🔍 检测到JSON格式选项，尝试解析');
        final List<dynamic> jsonOptions = jsonDecode(optionsStr);
        final choices = jsonOptions.map((option) {
          if (option is Map<String, dynamic>) {
            return option['desc']?.toString() ?? '';
          }
          return option.toString();
        }).where((text) => text.isNotEmpty).toList();

        debugPrint('✅ JSON格式解析成功，解析到 ${choices.length} 个选项: $choices');
        return choices;
      }

      // 尝试按行分割
      final lines = optionsStr.split(RegExp(r'[\n\r]+'))
          .map((line) => line.trim())
          .where((line) => line.isNotEmpty)
          .toList();

      if (lines.length > 1) {
        debugPrint('✅ 按行分割解析成功，解析到 ${lines.length} 个选项');
        return lines;
      }

      // 尝试按特定分隔符分割
      final parts = optionsStr.split(RegExp(r'[A-Z]\.|\d+\.'))
          .map((part) => part.trim())
          .where((part) => part.isNotEmpty)
          .toList();

      if (parts.length > 1) {
        debugPrint('✅ 按分隔符解析成功，解析到 ${parts.length} 个选项');
        return parts;
      }

      debugPrint('⚠️ 无法解析选项，返回单个选项');
      return [optionsStr];
    } catch (e) {
      debugPrint('❌ 选项解析失败: $e');
      return [optionsStr];
    }
  }

  // 查找正确选项索引
  static int _findSpreadsheetCorrectChoiceIndex(List<String> choices, String answer) {
    if (answer.isEmpty || choices.isEmpty) return 0;

    // 如果答案是字母（A、B、C、D）
    if (RegExp(r'^[A-Za-z]$').hasMatch(answer)) {
      final index = answer.toUpperCase().codeUnitAt(0) - 'A'.codeUnitAt(0);
      return index >= 0 && index < choices.length ? index : 0;
    }

    // 如果答案是数字
    final numIndex = int.tryParse(answer);
    if (numIndex != null) {
      return numIndex >= 0 && numIndex < choices.length ? numIndex : 0;
    }

    // 尝试在选项中查找匹配的文本
    for (int i = 0; i < choices.length; i++) {
      if (choices[i].contains(answer) || answer.contains(choices[i])) {
        return i;
      }
    }

    return 0;
  }

  // 解析多选答案
  static List<String> _parseSpreadsheetMultipleAnswers(String answer) {
    if (answer.isEmpty) return [];

    // 移除空格和分隔符，然后分割每个字符
    final cleanAnswer = answer.replaceAll(RegExp(r'[,，\s]+'), '');
    return cleanAnswer.split('').where((char) => char.isNotEmpty).toList();
  }

}